#include "session.h"
#include <QtCore/QString>
+#include <QtCore/QTextCodec>
#include <utility>
#include "src/core/datetime.h"
#include "src/core/optional.h"
* support category from GMSD "Garmin Special Data"
*/
+#include <algorithm> // for stable_sort
+#include <cctype> // for tolower
+#include <cstdio> // for NULL, SEEK_CUR, SEEK_SET
+#include <cstdlib> // for atoi
+#include <cstdint>
+#include <cstring> // for strcmp, strlen, strncmp, strncpy
+#include <ctime> // for time, gmtime
+
+#include <QtCore/QList> // for QList<>::iterator, QList
+#include <QtCore/QString> // for QString, operator+, operator<
+#include <QtCore/QThread> // for QThread
+#include <QtCore/Qt> // for CaseInsensitive
+#include <QtCore/QtGlobal> // for foreach, Q_UNUSED
+
#include "defs.h"
-#include "cet_util.h"
-#include "garmin_fs.h"
#include "garmin_gpi.h"
-#include "jeeps/gpsmath.h"
-#include <QtCore/QTextCodec>
-#include <QtCore/QThread>
-#include <cstdlib>
+#include "cet_util.h" // for cet_convert_init
+#include "garmin_fs.h" // for garmin_fs_t, garmin_fs_flags_t, GMSD_SET, GMSD_GET, garmin_fs_alloc, GMSD_FIND
+#include "gbfile.h" // for gbfputint32, gbfgetint32, gbfgetint16, gbfputint16, gbfgetc, gbfputc, gbfread, gbftell, gbfwrite, gbfseek, gbfclose, gbfile, gbfopen_le, gbsize_t, gbfgetuint16
+#include "jeeps/gpsmath.h" // for GPS_Math_Deg_To_Semi, GPS_Math_Semi_To_Deg
+
#define MYNAME "garmin_gpi"
QString category;
} reader_data_t;
-typedef struct writer_data_s {
- queue Q;
- int ct;
- int sz;
- int alert;
+struct writer_data_t {
+ QList<Waypoint*> waypt_list;
+ int sz{0};
+ int alert{0};
bounds bds;
- struct writer_data_s* top_left;
- struct writer_data_s* top_right;
- struct writer_data_s* buttom_left;
- struct writer_data_s* buttom_right;
-} writer_data_t;
+ writer_data_t* top_left{nullptr};
+ writer_data_t* top_right{nullptr};
+ writer_data_t* buttom_left{nullptr};
+ writer_data_t* buttom_right{nullptr};
+};
typedef struct gpi_waypt_data_s {
int sz;
gbfwrite(str, 1, len, fout);
}
-static int
-compare_wpt_cb(const queue* a, const queue* b)
+static bool
+compare_wpt_cb(const Waypoint* a, const Waypoint* b)
{
- const Waypoint* wa = reinterpret_cast<const Waypoint *>(a);
- const Waypoint* wb = reinterpret_cast<const Waypoint *>(b);
- return wa->shortname.compare(wb->shortname);
+ return a->shortname < b->shortname;
}
static char
static writer_data_t*
wdata_alloc()
{
- writer_data_t* res = (writer_data_t*) xcalloc(1, sizeof(*res));
- QUEUE_INIT(&res->Q);
+ auto res = new writer_data_t;
waypt_init_bounds(&res->bds);
return res;
static void
wdata_free(writer_data_t* data)
{
- queue* elem, *tmp;
-
- QUEUE_FOR_EACH(&data->Q, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
+ foreach (Waypoint* wpt, data->waypt_list) {
if (wpt->extra_data) {
gpi_waypt_t* dt = (gpi_waypt_t*) wpt->extra_data;
wdata_free(data->buttom_right);
}
- xfree(data);
+ delete data;
}
static void
wdata_add_wpt(writer_data_t* data, Waypoint* wpt)
{
- data->ct++;
- ENQUEUE_TAIL(&data->Q, &wpt->Q);
+ data->waypt_list.append(wpt);
waypt_add_to_bounds(&data->bds, wpt);
}
static void
wdata_check(writer_data_t* data)
{
- queue* elem, *tmp;
double center_lon;
- if ((data->ct <= WAYPOINTS_PER_BLOCK) ||
+ if ((data->waypt_list.size() <= WAYPOINTS_PER_BLOCK) ||
/* avoid endless loop for points (more than WAYPOINTS_PER_BLOCK)
at same coordinates */
((data->bds.min_lat >= data->bds.max_lat) && (data->bds.min_lon >= data->bds.max_lon))) {
- if (data->ct > 1) {
- sortqueue(&data->Q, compare_wpt_cb);
+ if (data->waypt_list.size() > 1) {
+ std::stable_sort(data->waypt_list.begin(), data->waypt_list.end(), compare_wpt_cb);
}
return;
}
/* compute the (mean) center of current bounds */
double center_lat = center_lon = 0;
- QUEUE_FOR_EACH(&data->Q, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
+ foreach (const Waypoint* wpt, data->waypt_list) {
center_lat += wpt->latitude;
center_lon += wpt->longitude;
}
- center_lat /= data->ct;
- center_lon /= data->ct;
+ center_lat /= data->waypt_list.size();
+ center_lon /= data->waypt_list.size();
- QUEUE_FOR_EACH(&data->Q, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
+ while (!data->waypt_list.isEmpty()) {
+ Waypoint* wpt = data->waypt_list.takeFirst();
writer_data_t** ref;
if (wpt->latitude < center_lat) {
*ref = wdata_alloc();
}
- data->ct--;
- dequeue(&wpt->Q);
-
wdata_add_wpt(*ref, wpt);
}
static int
wdata_compute_size(writer_data_t* data)
{
- queue* elem, *tmp;
int res = 0;
- if (QUEUE_EMPTY(&data->Q)) {
+ if (data->waypt_list.isEmpty()) {
goto skip_empty_block; /* do not issue an empty block */
}
res = 23; /* bounds, ... of tag 0x80008 */
- QUEUE_FOR_EACH(&data->Q, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
+ foreach (Waypoint* wpt, data->waypt_list) {
garmin_fs_t* gmsd;
res += 12; /* tag/sz/sub-sz */
data->sz = res;
- if (QUEUE_EMPTY(&data->Q)) {
+ if (data->waypt_list.isEmpty()) {
return res;
}
static void
wdata_write(const writer_data_t* data)
{
- queue* elem, *tmp;
-
- if (QUEUE_EMPTY(&data->Q)) {
+ if (data->waypt_list.isEmpty()) {
goto skip_empty_block; /* do not issue an empty block */
}
gbfputint16(1, fout);
gbfputc(data->alert, fout);
- QUEUE_FOR_EACH(&data->Q, elem, tmp) {
+ foreach (const Waypoint* wpt, data->waypt_list) {
int s1;
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
gpi_waypt_t* dt = (gpi_waypt_t*) wpt->extra_data;
QString str = wpt->description;
static void
enum_waypt_cb(const Waypoint* ref)
{
- queue* elem, *tmp;
-
- QUEUE_FOR_EACH(&wdata->Q, elem, tmp) {
- Waypoint* cmp = reinterpret_cast<Waypoint *>(elem);
+ foreach (const Waypoint* cmp, wdata->waypt_list) {
/* sort out nearly equal waypoints */
if ((compare_strings(cmp->shortname, ref->shortname) == 0) &&
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA
*/
+#include <cmath> // for fabs
+#include <cstdio> // for printf, snprintf, sscanf, SEEK_SET, NULL
+#include <cstdlib> // for atoi, strtol, NULL
+#include <cstring> // for memset, strcmp, strstr, strchr, strlen, strncpy
+#include <ctime> // for strftime
+
+#include <QtCore/QByteArray> // for QByteArray
+#include <QtCore/QList> // for QList
+#include <QtCore/QString> // for QString, operator!=, operator==
+#include <QtCore/Qt> // for CaseInsensitive
+#include <QtCore/QtGlobal> // for qPrintable, Q_UNUSED, foreach
+
#include "defs.h"
-#include "cet_util.h"
-#include "csv_util.h"
-#include "garmin_fs.h"
-#include "garmin_tables.h"
-#include "grtcirc.h"
-#include "jeeps/gpsmath.h"
-#include <cmath>
-#include <cstdlib>
+#include "cet_util.h" // for cet_convert_init
+#include "garmin_fs.h" // for garmin_fs_t, garmin_fs_flags_t, garmin_ilink_t, GMSD_GET, GMSD_SETSTR, GMSD_SET, garmin_fs_alloc, GMSD_FIND, GMSD_HAS
+#include "garmin_tables.h" // for gt_get_icao_country, gt_waypt_class_map_point, gt_color_index_by_rgb, gt_color_value, gt_waypt_classes_e, gt_find_desc_from_icon_number, gt_find_icon_number_from_desc, gt_gdb_display_mode_symbol, gt_waypt_class_user_waypoint, GDB, gt_display_mode_symbol
+#include "gbfile.h" // for gbfputint32, gbfgetint32, gbfread, gbfwrite, gbfgetc, gbfputc, gbfgetdbl, gbfgetcstr, gbfile, gbfclose, gbfputcstr, gbfcopyfrom, gbfrewind, gbfseek, gbftell, gbfopen_le, gbfgetcstr_old, gbfgetint16, gbfputdbl, gbfputint16
+#include "grtcirc.h" // for RAD, gcdist, radtometers
+#include "jeeps/gpsmath.h" // for GPS_Math_Deg_To_Semi, GPS_Math_Semi_To_Deg
+#include "queue.h" // for queue, QUEUE_FOR_EACH
+#include "src/core/datetime.h" // for DateTime
+
#define MYNAME "gdb"
static gbfile* fin, *fout, *ftmp;
static int gdb_ver, gdb_category, gdb_via, gdb_roadbook;
-static queue wayptq_in, wayptq_out, wayptq_in_hidden;
+static QList<Waypoint *> wayptq_in, wayptq_out, wayptq_in_hidden;
static short_handle short_h;
static char* gdb_opt_category;
#define NOT_EMPTY(a) (a && *a)
static void
-gdb_flush_waypt_queue(queue* Q)
+gdb_flush_waypt_queue(QList<Waypoint *>* Q)
{
- queue* elem, *tmp;
- QUEUE_FOR_EACH(Q, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(elem);
- dequeue(elem);
+ while(!Q->isEmpty()) {
+ const Waypoint* wpt = Q->takeFirst();
if (wpt->extra_data) {
#if NEW_STRINGS
// FIXME
}
}
-
#if GDB_DEBUG
static void
disp_summary(const gbfile* f)
}
static Waypoint*
-gdb_find_wayptq(const queue* Q, const Waypoint* wpt, const char exact)
+gdb_find_wayptq(const QList<Waypoint *>* Q, const Waypoint* wpt, const char exact)
{
- queue* elem, *tmp;
QString name = wpt->shortname;
-
- QUEUE_FOR_EACH(Q, elem, tmp) {
- Waypoint* tmp = reinterpret_cast<Waypoint *>(elem);
+ foreach (Waypoint* tmp, *Q) {
if (name.compare(tmp->shortname,Qt::CaseInsensitive) == 0) {
if (! exact) {
return tmp;
cet_convert_init(CET_CHARSET_UTF8, 1);
}
- QUEUE_INIT(&wayptq_in);
- QUEUE_INIT(&wayptq_in_hidden);
+ wayptq_in.clear();
+ wayptq_in_hidden.clear();
gdb_via = (gdb_opt_via && *gdb_opt_via) ? atoi(gdb_opt_via) : 0;
gdb_roadbook = (gdb_opt_roadbook && *gdb_opt_roadbook) ? atoi(gdb_opt_roadbook) : 0;
if ((gdb_via == 0) || (wpt_class == 0)) {
waypt_add(wpt);
Waypoint* dupe = new Waypoint(*wpt);
- ENQUEUE_TAIL(&wayptq_in, &dupe->Q);
+ wayptq_in.append(dupe);
} else {
- ENQUEUE_TAIL(&wayptq_in_hidden, &wpt->Q);
+ wayptq_in_hidden.append(wpt);
}
break;
case 'R':
Waypoint* wpt = new Waypoint(*refpt);
gdb_check_waypt(wpt);
- ENQUEUE_TAIL(&wayptq_out, &wpt->Q);
+ wayptq_out.append(wpt);
gbfile* fsave = fout;
fout = ftmp;
cet_convert_init(CET_CHARSET_UTF8, 1);
}
- QUEUE_INIT(&wayptq_out);
+ wayptq_out.clear();
short_h = nullptr;
waypt_ct = 0;
*/
-#include "defs.h"
-#include "explorist_ini.h"
-#include "gbser.h"
-#include "magellan.h"
+#include "defs.h" // might include config.h, which might define HAVE_GLOB.
+
+#include <cctype> // for isprint, toupper
+#include <cmath> // for fabs, lround
+#include <cstdio> // for sprintf, sscanf, snprintf, size_t
+#include <cstdlib> // for atoi, atof, strtoul
+#include <cstring> // for strchr, strncmp, strlen, memmove, strrchr, memset
+#include <ctime> // for gmtime
#if HAVE_GLOB
#include <glob.h>
#endif
-#include <QtCore/QFileInfo>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
+
+#include <QtCore/QByteArray> // for QByteArray
+#include <QtCore/QCharRef> // for QCharRef
+#include <QtCore/QFileInfo> // for QFileInfo
+#include <QtCore/QLatin1String> // for QLatin1String
+#include <QtCore/QList> // for QList
+#include <QtCore/QString> // for QString, operator==
+#include <QtCore/QTime> // for QTime
+#include <QtCore/Qt> // for CaseInsensitive
+#include <QtCore/QtGlobal> // for qPrintable, foreach
+
+#include "explorist_ini.h" // for explorist_ini_done, explorist_ini_get, mag_info
+#include "gbfile.h" // for gbfclose, gbfeof, gbfgets, gbfopen, gbfwrite, gbfile
+#include "gbser.h" // for gbser_deinit, gbser_init, gbser_is_serial, gbser_read_line, gbser_set_port, gbser_write, gbser_OK
+#include "magellan.h" // for mm_meridian, mm_sportrak, icon_mapping_t, mm_gps315320, mm_unknown, mm_map330, mm_map410, pid_to_model_t, mm_gps310, m330_cleanse, mag_checksum, mag_find_descr_from_token, mag_find_token_from_descr, mag_rteparse, mag_trkparse
+#include "queue.h" // for queue, QUEUE_FOR_EACH
+#include "src/core/datetime.h" // for DateTime
+
static int bitrate = 4800;
static int wptcmtcnt;
/*
* An individual element of a route.
*/
-class mag_rte_elem {
- public:
- mag_rte_elem() {
- QUEUE_INIT(&Q);
- }
- queue Q; /* My link pointers */
+struct mag_rte_elem {
QString wpt_name;
QString wpt_icon;
};
/*
* A header of a route. Related elements of a route belong to this.
*/
-typedef struct mag_rte_head_ {
- queue Q; /* Queue head for child rte_elems */
- char* rte_name;
- int nelems;
-} mag_rte_head;
+struct mag_rte_head_t {
+ QList<mag_rte_elem*> elem_list; /* list of child rte_elems */
+ char* rte_name{nullptr};
+ int nelems{0};
+};
-static queue rte_wpt_tmp; /* temporary PGMNWPL msgs for routes */
+static QList<Waypoint*> rte_wpt_tmp; /* temporary PGMNWPL msgs for routes */
static gbfile* magfile_h;
static mag_rxstate magrxstate;
if (extension_hint == WPTDATAMASK) {
waypt_add(wpt);
} else if (extension_hint == RTEDATAMASK) {
- ENQUEUE_TAIL(&rte_wpt_tmp, &wpt->Q);
+ rte_wpt_tmp.append(wpt);
}
} else {
switch (objective) {
waypt_add(wpt);
break;
case rtedata:
- ENQUEUE_TAIL(&rte_wpt_tmp, &wpt->Q);
+ rte_wpt_tmp.append(wpt);
break;
default:
break;
terminit(portname, 0);
mag_serial_init_common(portname);
- QUEUE_INIT(&rte_wpt_tmp);
+ rte_wpt_tmp.clear();
/* find the location of the tail of the path name,
* make a copy of it, then lop off the file extension
terminit(portname, 1);
mag_serial_init_common(portname);
- QUEUE_INIT(&rte_wpt_tmp);
+ rte_wpt_tmp.clear();
}
/*
mkshort_del_handle(&mkshort_handle);
}
- waypt_flush(&rte_wpt_tmp);
+ while (!rte_wpt_tmp.isEmpty()) {
+ delete rte_wpt_tmp.takeFirst();
+ }
trk_head = nullptr;
int frags,frag,rtenum;
char xbuf[100],next_stop[100],abuf[100];
char* currtemsg;
- static mag_rte_head* mag_rte_head;
+ static mag_rte_head_t* mag_rte_head;
char* p;
#if 0
* queue head.
*/
if (frag == 1) {
- mag_rte_head = (struct mag_rte_head_*) xcalloc(sizeof(*mag_rte_head),1);
- QUEUE_INIT(&mag_rte_head->Q);
+ mag_rte_head = new mag_rte_head_t;
mag_rte_head->nelems = frags;
}
rte_elem->wpt_name = next_stop;
rte_elem->wpt_icon = abuf;
- ENQUEUE_TAIL(&mag_rte_head->Q, &rte_elem->Q);
+ mag_rte_head->elem_list.append(rte_elem);
/* Sportrak (the non-mapping unit) creates malformed
* RTE sentence with no icon info after the routepoint
rte_elem = new mag_rte_elem;
rte_elem->wpt_name = abuf;
- ENQUEUE_TAIL(&mag_rte_head->Q, &rte_elem->Q);
+ mag_rte_head->elem_list.append(rte_elem);
}
next_stop[0] = 0;
* gpsbabel internal structs now.
*/
if (frag == mag_rte_head->nelems) {
- queue* elem, *tmp;
route_head* rte_head = route_head_alloc();
route_add_head(rte_head);
* those in the queue for SD routes...
*/
- QUEUE_FOR_EACH(&mag_rte_head->Q, elem, tmp) {
- mag_rte_elem* re = reinterpret_cast<mag_rte_elem *>(elem);
- queue* welem, *wtmp;
+ while (!mag_rte_head->elem_list.isEmpty()) {
+ mag_rte_elem* re = mag_rte_head->elem_list.takeFirst();
/*
* Copy route points from temp wpt queue.
*/
- QUEUE_FOR_EACH(&rte_wpt_tmp, welem, wtmp) {
- Waypoint* waypt = reinterpret_cast<Waypoint *>(welem);
+ foreach (const Waypoint* waypt, rte_wpt_tmp) {
if (waypt->shortname == re->wpt_name) {
Waypoint* wpt = new Waypoint(*waypt);
route_add_wpt(rte_head, wpt);
}
}
- dequeue(&re->Q);
delete re;
}
- xfree(mag_rte_head);
+ delete mag_rte_head;
}
}
/* #define MPS_DEBUG 0 */
+#include <cstdio> // for SEEK_CUR, sprintf, SEEK_SET, EOF, size_t
+#include <cstdlib> // for atoi, rand, srand
+#include <cstring> // for strcpy, memset, strlen, strcmp
+#include <ctime> // for time_t
+
+#include <QtCore/QChar> // for QChar
+#include <QtCore/QFile> // for QFile
+#include <QtCore/QList> // for QList
+#include <QtCore/QString> // for QString, operator==
+
#include "defs.h"
-#include "garmin_tables.h"
-#include "jeeps/gpsmath.h"
-#include <QtCore/QFile>
-#include <cstdio>
-#include <cstdlib>
+#include "garmin_tables.h" // for gt_find_icon_number_from_desc, MAPSOURCE, gt_find_desc_from_icon_number, GARMIN_SERIAL, PCX, garmin_formats_e
+#include "gbfile.h" // for gbfwrite, gbfread, gbfgetint32, gbfputint32, gbfseek, gbfputc, gbfgetc, gbfputdbl, gbfgetdbl, gbfclose, gbfeof, gbfile, gbftell, gbfgetcstr, gbfputs, gbfopen_le
+#include "jeeps/gpsmath.h" // for GPS_Math_Deg_To_Semi, GPS_Math_Semi_To_Deg
+#include "queue.h" // for queue, QUEUE_FOR_EACH
+#include "src/core/datetime.h" // for DateTime
+
static gbfile* mps_file_in;
static gbfile* mps_file_out;
static const Waypoint* prevRouteWpt;
/* Private queues of written out waypoints */
-static queue written_wpt_head;
-static queue written_route_wpt_head;
+static QList<Waypoint *> written_wpt_head;
+static QList<Waypoint *> written_route_wpt_head;
static short_handle written_wpt_mkshort_handle;
/* Private queue of read in waypoints assumed to be used only for routes */
-static queue read_route_wpt_head;
+static QList<Waypoint *> read_route_wpt_head;
static short_handle read_route_wpt_mkshort_handle;
#define MPSDEFAULTWPTCLASS 0
}
static void
-mps_wpt_q_init(queue* whichQueue)
+mps_wpt_q_init(QList<Waypoint *>* whichQueue)
{
- QUEUE_INIT(whichQueue);
+ whichQueue->clear();
}
static void
-mps_wpt_q_deinit(queue* whichQueue)
+mps_wpt_q_deinit(QList<Waypoint *>* whichQueue)
{
- queue* elem, *tmp;
-
- QUEUE_FOR_EACH(whichQueue, elem, tmp) {
- Waypoint* q = reinterpret_cast<Waypoint *>(dequeue(elem));
- delete q;
+ while (!whichQueue->isEmpty()) {
+ delete whichQueue->takeFirst();
}
}
*
*/
static Waypoint*
-mps_find_wpt_q_by_name(const queue* whichQueue, const QString& name)
+mps_find_wpt_q_by_name(const QList<Waypoint *>* whichQueue, const QString& name)
{
- queue* elem, *tmp;
-
- QUEUE_FOR_EACH(whichQueue, elem, tmp) {
- Waypoint* waypointp = reinterpret_cast<Waypoint*>(elem);
+ foreach (Waypoint* waypointp, *whichQueue) {
if (waypointp->shortname == name) {
return waypointp;
}
*
*/
static void
-mps_wpt_q_add(const queue* whichQueue, const Waypoint* wpt)
+mps_wpt_q_add(QList<Waypoint *>* whichQueue, const Waypoint* wpt)
{
Waypoint* written_wpt = new Waypoint(*wpt);
- ENQUEUE_TAIL(whichQueue, &written_wpt->Q);
+ whichQueue->append(written_wpt);
}
static int
*/
+#include <cctype> // for isprint
+#include <cmath> // for fabs, lround
+#include <cstdio> // for snprintf, sscanf, NULL, fprintf, fputc, stderr
+#include <cstdlib> // for atoi, atof
+#include <cstring> // for strncmp, memset, strlen, strchr, strstr, strrchr
+#include <ctime> // for gmtime
+
+#include <QtCore/QByteArray> // for QByteArray
+#include <QtCore/QChar> // for QChar, operator==, operator!=
+#include <QtCore/QCharRef> // for QCharRef
+#include <QtCore/QDateTime> // for QDateTime
+#include <QtCore/QList> // for QList
+#include <QtCore/QString> // for QString, QString::KeepEmptyParts
+#include <QtCore/QStringList> // for QStringList
+#include <QtCore/QThread> // for QThread
+#include <QtCore/QTime> // for QTime
+#include <QtCore/QtGlobal> // for qPrintable
#include "defs.h"
-#include "cet_util.h"
-#include "gbser.h"
-#include "jeeps/gpsmath.h"
-#include "src/core/logging.h"
-#include "strptime.h"
+#include "cet_util.h" // for cet_convert_init
+#include "gbfile.h" // for gbfprintf, gbfflush, gbfclose, gbfopen, gbfgetstr, gbfile
+#include "gbser.h" // for gbser_set_speed, gbser_flush, gbser_read_line, gbser_deinit, gbser_init, gbser_write
+#include "jeeps/gpsmath.h" // for GPS_Lookup_Datum_Index, GPS_Math_Known_Datum_To_WGS84_M
+#include "queue.h" // for queue, QUEUE_FOR_EACH, QUEUE_LAST
+#include "src/core/datetime.h" // for DateTime
+#include "src/core/logging.h" // for Warning
+#include "strptime.h" // for strptime
-#include <cctype>
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-
-#include <QtCore/QStringList>
-#include <QtCore/QThread>
/**********************************************************
static Waypoint* last_waypt;
static void* gbser_handle;
static QString posn_fname;
-static queue pcmpt_head;
+static QList<Waypoint*> pcmpt_head;
static int without_date; /* number of created trackpoints without a valid date */
static struct tm opt_tm; /* converted "date" parameter */
CHECK_BOOL(opt_gpgsa);
CHECK_BOOL(opt_gisteq);
- QUEUE_INIT(&pcmpt_head);
+ pcmpt_head.clear();
if (getposnarg) {
getposn = 1;
dmy = dmy / 100;
tm.tm_mday = dmy;
nmea_set_waypoint_time(curr_waypt, &tm, 0);
- ENQUEUE_HEAD(&pcmpt_head, &curr_waypt->Q);
+ pcmpt_head.prepend(curr_waypt);
} else {
- queue* elem, *tmp;
- if (QUEUE_EMPTY(&pcmpt_head)) {
+ if (pcmpt_head.isEmpty()) {
return;
}
*/
route_head* trk_head = route_head_alloc();
track_add_head(trk_head);
- QUEUE_FOR_EACH(&pcmpt_head, elem, tmp) {
- Waypoint* wpt = reinterpret_cast<Waypoint *>(dequeue(elem));
+ while (!pcmpt_head.isEmpty()) {
+ Waypoint* wpt = pcmpt_head.takeFirst();
nmea_add_wpt(wpt, trk_head);
}
}
#endif
Waypoint** comp;
int i, wc;
- queue temp_head;
route_head* rte_head = nullptr;
#if NEWQ
foreach (Waypoint* waypointp, waypt_list) {
}
wc = waypt_count();
- QUEUE_INIT(&temp_head);
comp = (Waypoint**) xcalloc(wc, sizeof(*comp));
*/
/*
- 2006/04/05: initial release (not published in GPSBbabel)
+ 2006/04/05: initial release (not published in GPSBabel)
2006/07/19: finished reader and writer for type 4,5,28 of ver. 1
2006/10/31: remove wptdata from case statement (data_write)
#if CSVFMTS_ENABLED
-#include "cet_util.h"
-#include "csv_util.h"
-#include "jeeps/gpsmath.h"
-#include "grtcirc.h"
-#include "src/core/logging.h"
+#include <algorithm> // for sort
+#include <cstdlib> // for atoi
+#include <cstring> // for strchr
+#include <ctime> // for localtime, strftime
+
+#include <QtCore/QDate> // for QDate
+#include <QtCore/QDateTime> // for QDateTime
+#include <QtCore/QList> // for QList<>::iterator, QList
+#include <QtCore/QRegularExpression> // for QRegularExpression
+#include <QtCore/QString> // for QString, operator+, QString::KeepEmptyParts
+#include <QtCore/QStringList> // for QStringList
+#include <QtCore/QTime> // for QTime
+#include <QtCore/QtGlobal> // for qAsConst, QAddConst<>::Type
+
+#include "cet_util.h" // for cet_convert_init
+#include "csv_util.h" // for csv_lineparse
+#include "gbfile.h" // for gbfprintf, gbfclose, gbfopen, gbfgetstr, gbfile
+#include "grtcirc.h" // for RAD, gcdist, heading_true_degrees, radtometers
+#include "jeeps/gpsmath.h" // for GPS_Lookup_Datum_Index, GPS_Math_WGS84_To_Known_Datum_M
+#include "src/core/datetime.h" // for DateTime
+#include "src/core/logging.h" // for Warning, Fatal
-#include <ctime>
-#include <cstdio>
-#include <cstdlib>
-#include <QtCore/QRegularExpression>
#define MYNAME "stmsdf"
static int datum;
static int filetype;
static route_head* route;
-static queue trackpts;
+static QList<Waypoint*> trackpts;
static QString rte_name;
static QString rte_desc;
static int this_points;
static int saved_points;
static time_t start_time;
-static unsigned char this_valid;
+static bool this_valid;
static short_handle short_h;
#define route_index this_index
}
}
-static int
-track_qsort_cb(const void* a, const void* b)
+static bool
+track_sort_cb(const Waypoint* a, const Waypoint* b)
{
- const Waypoint* wa = *(Waypoint**)a;
- const Waypoint* wb = *(Waypoint**)b;
-
- return wa->GetCreationTime().toTime_t() - wb->GetCreationTime().toTime_t();
+ return a->GetCreationTime() < b->GetCreationTime();
}
static void
finalize_tracks()
{
- queue* elem, *tmp;
route_head* track = nullptr;
int trackno = 0;
- int count = 0;
- QUEUE_FOR_EACH(&trackpts, elem, tmp) {
- count++;
- };
- if (count == 0) {
+ if (trackpts.isEmpty()) {
return;
}
- Waypoint** list = (Waypoint**)xmalloc(count * sizeof(*list));
-
- int index = 0;
- QUEUE_FOR_EACH(&trackpts, elem, tmp) {
- list[index] = reinterpret_cast<Waypoint *>(elem);
- dequeue(elem);
- index++;
- }
-
- qsort(list, count, sizeof(*list), track_qsort_cb);
+ std::sort(trackpts.begin(), trackpts.end(), track_sort_cb);
- for (index = 0; index < count; index++) {
- Waypoint* wpt = list[index];
+ foreach (Waypoint* wpt, trackpts) {
if (wpt->wpt_flags.fmt_use == 2) { /* log continued */
track = nullptr;
}
wpt->wpt_flags.fmt_use = 0;
}
- xfree(list);
+ trackpts.clear();
}
static void
switch (what) {
case 0:
case 1:
- ENQUEUE_TAIL(&trackpts, &wpt->Q);
+ trackpts.append(wpt);
break;
case 2:
case 3:
filetype = 28;
rte_name = rte_desc = QString();
- QUEUE_INIT(&trackpts);
+ trackpts.clear();
}
static void
projects / gpsbabel.git / commitdiff